Optimizacija Pandas DataFramea: Korištenje memorije i podešavanje performansi

Pandas je moćna Python biblioteka za manipulaciju i analizu podataka. Međutim, pri radu s velikim skupovima podataka, Pandas DataFrameovi mogu zauzeti značajnu količinu memorije i pokazati spore performanse. Ovaj članak pruža sveobuhvatan vodič za optimizaciju Pandas DataFrameova za korištenje memorije i performanse, omogućujući vam učinkovitiju obradu većih skupova podataka.

Razumijevanje korištenja memorije u Pandas DataFrameovima

Prije nego što zaronimo u tehnike optimizacije, ključno je razumjeti kako Pandas DataFrameovi pohranjuju podatke u memoriji. Svaki stupac u DataFrameu ima određeni tip podataka, koji određuje količinu memorije potrebnu za pohranjivanje njegovih vrijednosti. Uobičajeni tipovi podataka uključuju:

• int64: 64-bitni cijeli brojevi (zadano za cijele brojeve)
• float64: 64-bitni brojevi s pomičnim zarezom (zadano za brojeve s pomičnim zarezom)
• object: Python objekti (koristi se za stringove i mješovite tipove podataka)
• category: Kategorijski podaci (učinkovito za vrijednosti koje se ponavljaju)
• bool: Booleove vrijednosti (True/False)
• datetime64: Vrijednosti datuma i vremena

Tip podataka object često je najzahtjevniji za memoriju jer pohranjuje pokazivače na Python objekte, koji mogu biti znatno veći od primitivnih tipova podataka poput cijelih brojeva ili brojeva s pomičnim zarezom. Stringovi, čak i kratki, kada se pohranjuju kao `object`, troše daleko više memorije nego što je potrebno. Slično tome, korištenje int64 kada bi int32 bio dovoljan, rasipa memoriju.

Primjer: Provjera korištenja memorije DataFramea

Možete koristiti metodu memory_usage() za provjeru korištenja memorije DataFramea:

            import pandas as pd
import numpy as np

data = {
    'col1': np.random.randint(0, 1000, 100000),
    'col2': np.random.rand(100000),
    'col3': ['A', 'B', 'C'] * (100000 // 3 + 1)[:100000],
    'col4': ['This is a long string'] * 100000
}

df = pd.DataFrame(data)

memory_usage = df.memory_usage(deep=True)
print(memory_usage)
print(df.dtypes)

            

              
                Copy
              
            
          

Argument deep=True osigurava točan izračun korištenja memorije objekata (poput stringova). Bez deep=True, izračunat će se samo memorija za pokazivače, a ne za temeljne podatke.

Optimizacija tipova podataka

Jedan od najučinkovitijih načina za smanjenje korištenja memorije jest odabir najprikladnijih tipova podataka za stupce vašeg DataFramea. Evo nekih uobičajenih tehnika:

1. Smanjivanje numeričkih tipova podataka (Downcasting)

Ako vaši stupci s cijelim brojevima ili brojevima s pomičnim zarezom ne zahtijevaju puni raspon 64-bitne preciznosti, možete ih smanjiti na manje tipove podataka kao što su int32, int16, float32 ili float16. To može značajno smanjiti korištenje memorije, posebno za velike skupove podataka.

Primjer: Razmotrite stupac koji predstavlja dob, koja vjerojatno neće premašiti 120. Pohranjivanje kao int64 je rasipno; int8 (raspon od -128 do 127) bio bi prikladniji.

            def downcast_numeric(df):
    """Downcasts numeric columns to the smallest possible data type."""
    for col in df.columns:
        if pd.api.types.is_integer_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='integer')
        elif pd.api.types.is_float_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='float')
    return df

df = downcast_numeric(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

Funkcija pd.to_numeric() s argumentom downcast koristi se za automatski odabir najmanjeg mogućeg tipa podataka koji može predstavljati vrijednosti u stupcu. Korištenje copy() izbjegava modificiranje izvornog DataFramea. Uvijek provjerite raspon vrijednosti u svojim podacima prije smanjivanja tipa kako biste osigurali da ne izgubite informacije.

2. Korištenje kategorijskih tipova podataka

Ako stupac sadrži ograničen broj jedinstvenih vrijednosti, možete ga pretvoriti u tip podataka category. Kategorijski tipovi podataka pohranjuju svaku jedinstvenu vrijednost samo jednom, a zatim koriste cjelobrojne kodove za predstavljanje vrijednosti u stupcu. To može značajno smanjiti korištenje memorije, posebno za stupce s visokim udjelom ponovljenih vrijednosti.

Primjer: Razmotrite stupac koji predstavlja kodove država. Ako radite s ograničenim skupom država (npr. samo zemlje Europske unije), pohranjivanje ovoga kao kategorije bit će mnogo učinkovitije od pohranjivanja kao stringova.

            def optimize_categories(df):
    """Converts object columns with low cardinality to categorical type."""
    for col in df.columns:
        if df[col].dtype == 'object':
            num_unique_values = len(df[col].unique())
            num_total_values = len(df[col])
            if num_unique_values / num_total_values < 0.5:
                df[col] = df[col].astype('category')
    return df

df = optimize_categories(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

Ovaj kod provjerava je li broj jedinstvenih vrijednosti u stupcu tipa object manji od 50% ukupnih vrijednosti. Ako jest, pretvara stupac u kategorijski tip podataka. Prag od 50% je proizvoljan i može se prilagoditi ovisno o specifičnim karakteristikama vaših podataka. Ovaj je pristup najkorisniji kada stupac sadrži mnogo ponovljenih vrijednosti.

3. Izbjegavanje tipa podataka Object za stringove

Kao što je ranije spomenuto, tip podataka object često je najzahtjevniji za memoriju, posebno kada se koristi za pohranu stringova. Ako je moguće, pokušajte izbjegavati korištenje tipa podataka object za stupce sa stringovima. Kategorijski tipovi su poželjniji za stringove s niskom kardinalnošću. Ako je kardinalnost visoka, razmislite mogu li se stringovi predstaviti numeričkim kodovima ili se podaci u obliku stringa mogu u potpunosti izbjeći.

Ako trebate izvoditi operacije sa stringovima na stupcu, možda ćete ga morati zadržati kao tip object, ali razmislite mogu li se te operacije izvesti unaprijed, a zatim stupac pretvoriti u učinkovitiji tip.

4. Podaci o datumu i vremenu

Koristite tip podataka datetime64 za informacije o datumu i vremenu. Osigurajte da je rezolucija prikladna (rezolucija nanosekunde možda je nepotrebna). Pandas vrlo učinkovito rukuje podacima vremenskih serija.

Optimizacija operacija s DataFrameom

Osim optimizacije tipova podataka, možete poboljšati i performanse Pandas DataFrameova optimizacijom operacija koje na njima izvodite. Evo nekih uobičajenih tehnika:

1. Vektorizacija

Vektorizacija je proces izvođenja operacija na cijelim nizovima ili stupcima odjednom, umjesto iteriranja preko pojedinačnih elemenata. Pandas je visoko optimiziran za vektorizirane operacije, pa njihovo korištenje može značajno poboljšati performanse. Izbjegavajte eksplicitne petlje kad god je to moguće. Ugrađene funkcije Pandasa općenito su mnogo brže od ekvivalentnih Python petlji.

Primjer: Umjesto iteriranja kroz stupac za izračun kvadrata svake vrijednosti, koristite funkciju pow():

            # Inefficient (using a loop)
import time

start_time = time.time()
results = []
for value in df['col2']:
    results.append(value ** 2)
df['col2_squared_loop'] = results
end_time = time.time()
print(f"Loop time: {end_time - start_time:.4f} seconds")

# Efficient (using vectorization)
start_time = time.time()
df['col2_squared_vectorized'] = df['col2'] ** 2
end_time = time.time()
print(f"Vectorized time: {end_time - start_time:.4f} seconds")


            

              
                Copy
              
            
          

Vektorizirani pristup je obično redovima veličine brži od pristupa temeljenog na petlji.

2. Oprezno korištenje metode `apply()`

Metoda apply() omogućuje primjenu funkcije na svaki redak ili stupac DataFramea. Međutim, općenito je sporija od vektoriziranih operacija jer uključuje pozivanje Python funkcije za svaki element. Koristite apply() samo kada vektorizirane operacije nisu moguće.

Ako morate koristiti apply(), pokušajte što je više moguće vektorizirati funkciju koju primjenjujete. Razmislite o korištenju Numba-inog dekoratora `jit` za kompajliranje funkcije u strojni kod radi značajnog poboljšanja performansi.

            from numba import jit

@jit(nopython=True)
def my_function(x):
    return x * 2  # Example function

df['col2_applied'] = df['col2'].apply(my_function)

            

              
                Copy
              
            
          

3. Učinkovito odabiranje stupaca

Pri odabiru podskupa stupaca iz DataFramea, koristite sljedeće metode za optimalne performanse:

• Izravan odabir stupaca: df[['col1', 'col2']] (najbrže za odabir nekoliko stupaca)
• Booleovo indeksiranje: df.loc[:, [True if col.startswith('col') else False for col in df.columns]] (korisno za odabir stupaca na temelju uvjeta)

Izbjegavajte korištenje df.filter() s regularnim izrazima za odabir stupaca, jer može biti sporije od drugih metoda.

4. Optimizacija spajanja (Joins i Merges)

Spajanje i mergeanje DataFrameova može biti računski zahtjevno, posebno za velike skupove podataka. Evo nekoliko savjeta za optimizaciju spajanja:

• Koristite odgovarajuće ključeve za spajanje: Osigurajte da ključevi za spajanje imaju isti tip podataka i da su indeksirani.
• Navedite vrstu spajanja: Koristite odgovarajuću vrstu spajanja (npr. inner, left, right, outer) prema vašim zahtjevima. Unutarnje spajanje (inner join) je općenito brže od vanjskog spajanja (outer join).
• Koristite `merge()` umjesto `join()`: Funkcija merge() je svestranija i često brža od metode join().

Primjer:

            df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value1': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value2': [5, 6, 7, 8]})

# Efficient inner join
df_merged = pd.merge(df1, df2, on='key', how='inner')

print(df_merged)

            

              
                Copy
              
            
          

5. Izbjegavanje nepotrebnog kopiranja DataFrameova

Mnoge Pandas operacije stvaraju kopije DataFrameova, što može biti memorijski i vremenski zahtjevno. Da biste izbjegli nepotrebno kopiranje, koristite argument inplace=True kada je dostupan ili dodijelite rezultat operacije natrag izvornom DataFrameu. Budite vrlo oprezni s inplace=True jer može prikriti pogreške i otežati ispravljanje pogrešaka. Često je sigurnije ponovno dodijeliti, iako je nešto manje performantno.

Primjer:

            # Inefficient (creates a copy)
df_filtered = df[df['col1'] > 500]

# Efficient (modifies the original DataFrame in place - CAUTION)
df.drop(df[df['col1'] <= 500].index, inplace=True)

#SAFER - reassigns, avoids inplace
df = df[df['col1'] > 500]

            

              
                Copy
              
            
          

6. Obrada u dijelovima (Chunking) i iteriranje

Za izuzetno velike skupove podataka koji se ne mogu smjestiti u memoriju, razmislite o obradi podataka u dijelovima. Koristite parametar chunksize pri čitanju podataka iz datoteka. Iterirajte kroz dijelove i izvodite analizu na svakom dijelu zasebno. To zahtijeva pažljivo planiranje kako bi se osiguralo da analiza ostane točna, jer neke operacije zahtijevaju obradu cijelog skupa podataka odjednom.

            # Read CSV in chunks
for chunk in pd.read_csv('large_data.csv', chunksize=100000):
    # Process each chunk
    print(chunk.shape)

            

              
                Copy
              
            
          

7. Korištenje Daska za paralelnu obradu

Dask je biblioteka za paralelno računanje koja se besprijekorno integrira s Pandasom. Omogućuje vam paralelnu obradu velikih DataFrameova, što može značajno poboljšati performanse. Dask dijeli DataFrame na manje particije i distribuira ih na više jezgri ili računala.

            import dask.dataframe as dd

# Create a Dask DataFrame
ddf = dd.read_csv('large_data.csv')

# Perform operations on the Dask DataFrame
ddf_filtered = ddf[ddf['col1'] > 500]

# Compute the result (this triggers the parallel computation)
result = ddf_filtered.compute()

print(result.head())

            

              
                Copy
              
            
          

Indeksiranje za brže pretrage

Stvaranje indeksa na stupcu može značajno ubrzati operacije pretraživanja i filtriranja. Pandas koristi indekse za brzo pronalaženje redaka koje odgovaraju određenoj vrijednosti.

Primjer:

            # Set 'col3' as the index
df = df.set_index('col3')

# Faster lookup
value = df.loc['A']

print(value)

# Reset the index
df = df.reset_index()

            

              
                Copy
              
            
          

Međutim, stvaranje previše indeksa može povećati korištenje memorije i usporiti operacije pisanja. Stvarajte indekse samo na stupcima koji se često koriste za pretraživanje ili filtriranje.

Ostala razmatranja

• Hardver: Razmislite o nadogradnji hardvera (CPU, RAM, SSD) ako stalno radite s velikim skupovima podataka.
• Softver: Provjerite koristite li najnoviju verziju Pandasa, jer novije verzije često uključuju poboljšanja performansi.
• Profiliranje: Koristite alate za profiliranje (npr. cProfile, line_profiler) kako biste identificirali uska grla u performansama vašeg koda.
• Format za pohranu podataka: Razmislite o korištenju učinkovitijih formata za pohranu podataka poput Parqueta ili Feathera umjesto CSV-a. Ovi su formati stupčani i često komprimirani, što dovodi do manjih datoteka i bržeg čitanja/pisanja.

Zaključak

Optimizacija Pandas DataFrameova za korištenje memorije i performanse ključna je za učinkovit rad s velikim skupovima podataka. Odabirom odgovarajućih tipova podataka, korištenjem vektoriziranih operacija i učinkovitim indeksiranjem podataka možete značajno smanjiti potrošnju memorije i poboljšati performanse. Ne zaboravite profiliranati svoj kod kako biste identificirali uska grla u performansama i razmislite o korištenju obrade u dijelovima ili Daska za izuzetno velike skupove podataka. Primjenom ovih tehnika možete otključati puni potencijal Pandasa za analizu i manipulaciju podacima.